package structuresManagers;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;

import mainPackage.DatosUrl;

import register.Register;
import FilesManagers.CantOpenFileException;
import FilesManagers.FileManager;
import FilesManagers.FullUrlManager;
import FilesManagers.NoMoreLinesException;
import Filters.FullFilter;

public class DocumentsManager {
	private String urls;
	private FileManager manejadorUrls;
	private FullFilter filtroLinea;
	private int contadorUrls;
	private String urlsProcesedFile,urlsTemp;
	private ArrayList<String> listaPalabras;
	private boolean logger;

	private DocumentsManager(String urls, FullFilter filtro) throws CantOpenFileException{
		this.urls=urls;
		filtroLinea= filtro;
		manejadorUrls = new FileManager();
		contadorUrls=0;
		urlsTemp="urlsTemp.txt";
		logger=false;
	//	this.organizarUrls();
		
	}

	public DocumentsManager(String urls, String urlsProcesadas,FullFilter filtro) throws CantOpenFileException{
		this(urls,filtro);
		urlsProcesedFile =urlsProcesadas;
		
	}
		
	private int getUrlNumber(String url){
		FileManager manejadorArchivo = new FileManager();
		try {
			manejadorArchivo.cargarArchivo(urlsProcesedFile);			
		} catch (CantOpenFileException e1) {
			// TODO Bloque catch generado automáticamente
			contadorUrls++;
			FileManager.append(urlsProcesedFile,""+contadorUrls+","+url+"\n");
			return contadorUrls;
			//e1.printStackTrace();
		}		
		
		String linea=null;
		try {
			while((linea=manejadorArchivo.obtenerSiguienteLinea())!=null){
				String[] args=linea.split(",");
				if(args[1].equals(url)){
					return Integer.parseInt(args[0]);
					
				}
				if(args[0]!=null && args[0]!="")this.contadorUrls=Integer.parseInt(args[0]);
				
			}
		} catch (NoMoreLinesException e) {
			contadorUrls++;			
			FileManager.append(urlsProcesedFile,""+contadorUrls+","+url+"\n");
			return contadorUrls;
			// TODO Bloque catch generado automáticamente
			//e.printStackTrace();
		}
		
		contadorUrls++;		
		FileManager.append(urlsProcesedFile,contadorUrls+","+url+"\n");
		return contadorUrls;		
	}
	
	
	public void organizarUrls() throws CantOpenFileException{
		/*Proceso el archivo de urls para armarme un archivo temporal, en este
		 * se incluiran las url del tipo http , los archivos locales y los resultados 
		 * de los directorios ya procesados, o sea la direccion de sus archivos */
		FileManager.borrar(urlsTemp);
		manejadorUrls = new FileManager();
		manejadorUrls.cargarArchivo(this.urls);
		manejadorUrls.setMarcadorComentario('#');
		String linea;
		FullUrlManager url = new FullUrlManager();
		try {
			while(((linea = manejadorUrls.obtenerSiguienteLinea())!=null)){
				Iterator<String> itHtmls = url.getItOfHtmlFiles(linea);
				/*Uso un archivo temporal por si tengo directorios en los cuales debo procesar sus archivos*/
				while(itHtmls.hasNext()){
					FileManager.append(urlsTemp,itHtmls.next()+"\n");//linea = itHtmls.next();
				}
			}
		} catch (NoMoreLinesException e) {
			// TODO Bloque catch generado automáticamente
			//e.printStackTrace();
		}
		manejadorUrls.cerrarArchivo();
		manejadorUrls.cargarArchivo(urlsTemp);		
	}
	
	public String[] obtenerUrlRegistro(Register reg) throws CantOpenFileException{
		String args[]=reg.toStringList().split("\\|\\|");
		if(args.length>1){
			args=args[1].trim().split("\\|");
			for (int i=0;i<args.length;i++){
				args[i]=this.getUrlNumber(Integer.parseInt(args[i]));			
			}
		}else{
			return null;
		}
		return args;		
	}
	
		
	private String getUrlNumber(int nro) throws CantOpenFileException{
		FileManager manejadorArchivo = new FileManager();
		try {
			manejadorArchivo.cargarArchivo(this.urlsProcesedFile);
		} catch (CantOpenFileException e1) {
			throw new CantOpenFileException("No existe el archivo con las url indexadas, debe generar la estructura  nuevamente");
		}
		String linea=null;
		try {
			while((linea=manejadorArchivo.obtenerSiguienteLinea())!=null){
				String[] args=linea.split(",");
				if(Integer.parseInt(args[0])==(nro)){
					return args[1];
					
				}				
			}
		} catch (NoMoreLinesException e) {
			//e.printStackTrace();
			
		}finally{
			manejadorArchivo.cerrarArchivo();			
			
		}
		return null;
	}
	
	
	private void devolverAuxiliar(String linea){
		linea = filtroLinea.procesarLinea(linea);
	
		if((linea.trim().compareTo("")!=0)||(filtroLinea.getUltimaLinea())){ 
			//System.out.println(linea);
			String palabras[]= linea.split(" ");
			for(int i=0;i<palabras.length;i++){
				int posLista =listaPalabras.indexOf(palabras[i]);
				
				/*Si ya existe no la pongo en llista otra vez, deberia aumentar el contador*/
				
				if(posLista==-1){
					listaPalabras.add(palabras[i]);
				
				}else{
					//deberia aculmular las cantidades, todavia no es necesario ------------- FINISH ME
					//System.out.println("----Ya existia "+palabras[i]);
				}
				
			}
		}
		
	}
	
	
	/* Lee el siguiente url, lo copia a disco en un archivo temporal,  extrae el numero y la lista de palabras 
	 * y los retorna en la un objeto de tipo DatosUrl
	 *  */
	public DatosUrl devolverPalabrasSiguiente () throws CantOpenFileException{
		DatosUrl datosUrl = new DatosUrl();
		listaPalabras = new ArrayList<String>();
		int contadorUrls=0;
		String archivoTemporal="temp.html";
		String linea="";
		
		FileManager manejadorArchivo = new FileManager();
		FullUrlManager url = new FullUrlManager();

		try{
			if(((linea = manejadorUrls.obtenerSiguienteLinea())!=null)){
							
					if(logger)FileManager.append("log.txt","**************************\n");
					System.out.println("**************************");
					if(logger)FileManager.append("log.txt","Procesando URL "+linea+"\n");
					System.out.println("Procesando URL "+linea);
					
					/*El primer parametro es la url remota, el segundo el nombre que le quiero poner en disco, si se deja vacio usa el mismo nombre del html remoto*/
					try{
						url.copiar(linea,archivoTemporal);
					}catch(CantOpenFileException e){
						System.err.println(e.getMessage());
						return devolverPalabrasSiguiente();
					}
					
					contadorUrls=this.getUrlNumber(linea);
					manejadorArchivo.cargarArchivo(archivoTemporal,url.getCodificacion());
					try{
						filtroLinea.setUltimaLinea(false);
						while((linea = manejadorArchivo.obtenerSiguienteLinea())!=null){
							devolverAuxiliar(linea);
						}
						filtroLinea.setUltimaLinea(true);
						devolverAuxiliar(" ");
					}catch(NoMoreLinesException e){
						filtroLinea.setUltimaLinea(true);
						devolverAuxiliar(" ");
						manejadorArchivo.cerrarArchivo();
						
	
					}
			}else{
				return null;				
			}
		}catch(NoMoreLinesException e){
			//System.out.println(e.getMessage());
			manejadorUrls.cerrarArchivo();
			datosUrl= null;

		}
		
		FileManager.borrar(archivoTemporal);
		
		if(datosUrl!=null){
			datosUrl.setItPalabras(listaPalabras.iterator());
			datosUrl.setNumeroUrl(contadorUrls);
		}
		return datosUrl;



	}
	public void finalize(){
		manejadorUrls.cerrarArchivo();
		FileManager.borrar(urlsTemp);
		
	}
	public void restart(){
		this.contadorUrls=0;
		FileManager.borrar(urlsProcesedFile);
	}
	
	public String[] getUrlList() throws CantOpenFileException{
		FileManager manejadorArchivo = new FileManager();
		try {
			manejadorArchivo.cargarArchivo(this.urlsProcesedFile);
		} catch (CantOpenFileException e1) {
			throw new CantOpenFileException("No existe el archivo con las url indexadas, debe generar la estructura  nuevamente");
		}
		String linea=null;
		LinkedList<String> listaSalida=new LinkedList<String>();
		try {
			while((linea=manejadorArchivo.obtenerSiguienteLinea())!=null){
				String[] args=linea.split(",");
				listaSalida.add(args[1]);					
			}
		} catch (NoMoreLinesException e) {
			//e.printStackTrace();
			
		}finally{
			manejadorArchivo.cerrarArchivo();			
			
		}
		//ojo, no se que pasa si la lista esta vacia luego
		Iterator<String> iterador=listaSalida.iterator();
		String[] salida=new String[listaSalida.size()];
		for(int i=0; i<listaSalida.size(); i++){
			salida[i]=iterador.next();
		}
		return salida;
	}
	
}
